import { apiService } from './index'

/**
 * 认证相关 API
 */
export const authAPI = {
  /**
   * 用户登录
   * @param {Object} loginData - 登录数据
   * @param {string} loginData.username - 用户名
   * @param {string} loginData.password - 密码
   * @param {string} loginData.captcha - 验证码
   * @param {boolean} loginData.remember - 记住我
   */
  login: (loginData) => {
    return apiService.post('/auth/login', loginData)
  },

  /**
   * 用户登出
   */
  logout: () => {
    return apiService.post('/auth/logout')
  },

  /**
   * 获取用户信息
   */
  getUserInfo: () => {
    return apiService.get('/auth/profile')
  },

  /**
   * 刷新 token
   */
  refreshToken: () => {
    return apiService.post('/auth/refresh')
  },

  /**
   * 修改密码
   * @param {Object} passwordData - 密码数据
   * @param {string} passwordData.oldPassword - 旧密码
   * @param {string} passwordData.newPassword - 新密码
   */
  changePassword: (passwordData) => {
    return apiService.post('/auth/change-password', passwordData)
  },

  /**
   * 更新用户资料
   * @param {Object} profileData - 用户资料数据
   * @param {string} profileData.name - 姓名
   * @param {string} profileData.email - 邮箱
   * @param {string} profileData.phone - 手机号
   * @param {string} profileData.bio - 个人简介
   */
  updateProfile: (profileData) => {
    return apiService.put('/auth/profile', profileData)
  },

  /**
   * 用户注册
   * @param {Object} registerData - 注册数据
   * @param {string} registerData.username - 用户名
   * @param {string} registerData.password - 密码
   * @param {string} registerData.email - 邮箱
   * @param {string} registerData.emailCode - 邮箱验证码
   * @param {string} registerData.phone - 手机号
   * @param {string} registerData.smsCode - 手机验证码
   */
  register: (registerData) => {
    return apiService.post('/auth/register', registerData)
  },

  /**
   * 发送邮箱验证码
   * @param {Object} emailData - 邮箱数据
   * @param {string} emailData.email - 邮箱地址
   * @param {string} emailData.type - 验证码类型：register/reset
   */
  sendEmailCode: (emailData) => {
    return apiService.post('/auth/send-email-code', emailData)
  },

  /**
   * 发送手机验证码
   * @param {Object} phoneData - 手机数据
   * @param {string} phoneData.phone - 手机号码
   * @param {string} phoneData.type - 验证码类型：register/reset
   */
  sendSmsCode: (phoneData) => {
    return apiService.post('/auth/send-sms-code', phoneData)
  },

  /**
   * 忘记密码
   * @param {Object} forgotData - 忘记密码数据
   * @param {string} forgotData.email - 邮箱地址
   */
  forgotPassword: (forgotData) => {
    return apiService.post('/auth/forgot-password', forgotData)
  },

  /**
   * 重置密码
   * @param {Object} resetData - 重置密码数据
   * @param {string} resetData.token - 重置令牌
   * @param {string} resetData.newPassword - 新密码
   */
  resetPassword: (resetData) => {
    return apiService.post('/auth/reset-password', resetData)
  },

  /**
   * 获取注册审核列表
   * @param {Object} params - 查询参数
   */
  getRegistrationList: (params) => {
    return apiService.get('/auth/registrations', params)
  },

  /**
   * 审核注册申请
   * @param {number} id - 注册申请ID
   * @param {Object} approveData - 审核数据
   * @param {string} approveData.action - 操作：approve/reject
   * @param {string} approveData.reason - 审核原因
   */
  approveRegistration: (id, approveData) => {
    return apiService.post(`/auth/registrations/${id}/approve`, approveData)
  }
}

/**
 * 线路管理 API
 */
export const lineAPI = {
  /**
   * 获取线路列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {string} params.keyword - 搜索关键词（线路编号或名称）
   * @param {string} params.status - 状态
   * @param {string} params.region - 区域
   */
  getLines: (params) => {
    return apiService.get('/lines', params)
  },

  /**
   * 获取线路详情
   * @param {number} id - 线路ID
   */
  getLineDetail: (id) => {
    return apiService.get(`/lines/${id}`)
  },

  /**
   * 创建线路
   * @param {Object} lineData - 线路数据
   */
  createLine: (lineData) => {
    return apiService.post('/lines', lineData)
  },

  /**
   * 更新线路
   * @param {number} id - 线路ID
   * @param {Object} lineData - 线路数据
   */
  updateLine: (id, lineData) => {
    return apiService.put(`/lines/${id}`, lineData)
  },

  /**
   * 删除线路
   * @param {number} id - 线路ID
   */
  deleteLine: (id) => {
    return apiService.delete(`/lines/${id}`)
  },

  /**
   * 批量删除线路
   * @param {Array} ids - 线路ID数组
   */
  batchDeleteLines: (ids) => {
    return apiService.post('/lines/batch-delete', { ids })
  },

  /**
   * 获取线路统计信息
   */
  getLineStatistics: () => {
    return apiService.get('/lines/statistics')
  },

  /**
   * 获取里程桩列表
   * @param {number} lineId - 线路ID
   */
  getMilestones: (lineId) => {
    return apiService.get(`/lines/${lineId}/milestones`)
  },

  /**
   * 创建里程桩
   * @param {number} lineId - 线路ID
   * @param {Object} milestoneData - 里程桩数据
   */
  createMilestone: (lineId, milestoneData) => {
    return apiService.post(`/lines/${lineId}/milestones`, milestoneData)
  },

  /**
   * 批量创建里程桩
   * @param {number} lineId - 线路ID
   * @param {Object} batchData - 批量数据
   */
  batchCreateMilestones: (lineId, batchData) => {
    return apiService.post(`/lines/${lineId}/milestones/batch`, batchData)
  }
}

/**
 * 巡检管理 API
 */
export const inspectionAPI = {
  /**
   * 获取巡检计划列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {string} params.keyword - 搜索关键词（计划名称）
   * @param {string} params.status - 状态筛选
   * @param {string} params.cycle - 周期筛选
   */
  getPlans: (params) => {
    return apiService.get('/inspections/plans', params)
  },

  /**
   * 获取巡检计划详情
   * @param {number} id - 计划ID
   */
  getPlanDetail: (id) => {
    return apiService.get(`/inspections/plans/${id}`)
  },

  /**
   * 创建巡检计划
   * @param {Object} planData - 计划数据
   */
  createPlan: (planData) => {
    return apiService.post('/inspections/plans', planData)
  },

  /**
   * 更新巡检计划
   * @param {number} id - 计划ID
   * @param {Object} planData - 计划数据
   */
  updatePlan: (id, planData) => {
    return apiService.put(`/inspections/plans/${id}`, planData)
  },

  /**
   * 删除巡检计划
   * @param {number} id - 计划ID
   */
  deletePlan: (id) => {
    return apiService.delete(`/inspections/plans/${id}`)
  },

  /**
   * 获取巡检任务列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {string} params.keyword - 搜索关键词（任务编号或名称）
   * @param {string} params.status - 状态筛选
   * @param {string} params.cycle - 周期筛选
   * @param {number} params.planId - 计划ID筛选
   */
  getTasks: (params) => {
    return apiService.get('/inspections/tasks', params)
  },

  /**
   * 获取巡检任务详情
   * @param {number} id - 任务ID
   */
  getTaskDetail: (id) => {
    return apiService.get(`/inspections/tasks/${id}`)
  },

  /**
   * 创建巡检任务
   * @param {Object} taskData - 任务数据
   */
  createTask: (taskData) => {
    return apiService.post('/inspections/tasks', taskData)
  },

  /**
   * 更新巡检任务
   * @param {number} id - 任务ID
   * @param {Object} taskData - 任务数据
   */
  updateTask: (id, taskData) => {
    return apiService.put(`/inspections/tasks/${id}`, taskData)
  },

  /**
   * 删除巡检任务
   * @param {number} id - 任务ID
   */
  deleteTask: (id) => {
    return apiService.delete(`/inspections/tasks/${id}`)
  },

  /**
   * 分配巡检任务
   * @param {number} id - 任务ID
   * @param {Object} assignData - 分配数据
   */
  assignTask: (id, assignData) => {
    return apiService.post(`/inspections/tasks/${id}/assign`, assignData)
  },

  /**
   * 批量分配任务
   * @param {Object} batchData - 批量分配数据
   */
  batchAssignTasks: (batchData) => {
    return apiService.post('/inspections/tasks/batch-assign', batchData)
  },

  /**
   * 完成任务
   * @param {number} id - 任务ID
   * @param {Object} completeData - 完成数据
   */
  completeTask: (id, completeData) => {
    return apiService.post(`/inspections/tasks/${id}/complete`, completeData)
  },

  /**
   * 获取任务统计信息
   */
  getTaskStatistics: () => {
    return apiService.get('/inspections/tasks/statistics')
  }
}

/**
 * 缺陷管理 API
 */
export const defectAPI = {
  /**
   * 获取缺陷列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {string} params.keyword - 搜索关键词（缺陷编号、描述、位置）
   * @param {string} params.status - 状态筛选
   * @param {number} params.typeId - 类型ID筛选
   * @param {number} params.levelId - 等级ID筛选
   * @param {number} params.lineId - 线路ID筛选
   */
  getDefects: (params) => {
    return apiService.get('/defects', params)
  },

  /**
   * 获取缺陷详情
   * @param {number} id - 缺陷ID
   */
  getDefectDetail: (id) => {
    return apiService.get(`/defects/${id}`)
  },

  /**
   * 创建缺陷
   * @param {Object} defectData - 缺陷数据
   */
  createDefect: (defectData) => {
    return apiService.post('/defects', defectData)
  },

  /**
   * 更新缺陷
   * @param {number} id - 缺陷ID
   * @param {Object} defectData - 缺陷数据
   */
  updateDefect: (id, defectData) => {
    return apiService.put(`/defects/${id}`, defectData)
  },

  /**
   * 删除缺陷
   * @param {number} id - 缺陷ID
   */
  deleteDefect: (id) => {
    return apiService.delete(`/defects/${id}`)
  },

  /**
   * 批量删除缺陷
   * @param {Array} ids - 缺陷ID数组
   */
  batchDeleteDefects: (ids) => {
    return apiService.post('/defects/batch-delete', { ids })
  },

  /**
   * 更新缺陷状态
   * @param {number} id - 缺陷ID
   * @param {Object} statusData - 状态数据
   */
  updateDefectStatus: (id, statusData) => {
    return apiService.put(`/defects/${id}/status`, statusData)
  },

  /**
   * 获取缺陷类型字典
   */
  getDefectTypes: () => {
    return apiService.get('/defects/types')
  },

  /**
   * 获取缺陷等级字典
   */
  getDefectLevels: () => {
    return apiService.get('/defects/levels')
  },

  /**
   * 获取缺陷统计信息
   */
  getDefectStatistics: (params) => {
    return apiService.get('/defects/statistics', params)
  }
}

/**
 * 消缺管理 API
 */
export const remedyAPI = {
  /**
   * 获取消缺任务列表
   * @param {Object} params - 查询参数
   * @param {number} params.pageNum - 页码
   * @param {number} params.pageSize - 每页数量
   * @param {string} params.keyword - 搜索关键词（任务编号、描述）
   * @param {string} params.status - 状态筛选
   * @param {number} params.defectId - 缺陷ID筛选
   * @param {number} params.lineId - 线路ID筛选
   * @param {number} params.assigneeId - 负责人ID筛选
   */
  getRemedies: (params) => {
    return apiService.get('/remedy/tasks', params)
  },

  /**
   * 获取消缺任务详情
   * @param {number} id - 任务ID
   */
  getRemedyDetail: (id) => {
    return apiService.get(`/remedy/tasks/${id}`)
  },

  /**
   * 创建消缺任务
   * @param {Object} remedyData - 任务数据
   */
  createRemedy: (remedyData) => {
    return apiService.post('/remedy/tasks', remedyData)
  },

  /**
   * 更新消缺任务
   * @param {number} id - 任务ID
   * @param {Object} remedyData - 任务数据
   */
  updateRemedy: (id, remedyData) => {
    return apiService.put(`/remedy/tasks/${id}`, remedyData)
  },

  /**
   * 删除消缺任务
   * @param {number} id - 任务ID
   */
  deleteRemedy: (id) => {
    return apiService.delete(`/remedy/tasks/${id}`)
  },

  /**
   * 批量删除消缺任务
   * @param {Array} ids - 任务ID数组
   */
  batchDeleteRemedies: (ids) => {
    return apiService.post('/remedy/tasks/batch-delete', { ids })
  },

  /**
   * 更新任务状态
   * @param {number} id - 任务ID
   * @param {Object} statusData - 状态数据
   */
  updateRemedyStatus: (id, statusData) => {
    return apiService.put(`/remedy/tasks/${id}/status`, statusData)
  },

  /**
   * 分配消缺任务
   * @param {number} id - 任务ID
   * @param {Object} assignData - 分配数据
   */
  assignRemedy: (id, assignData) => {
    return apiService.post(`/remedy/tasks/${id}/assign`, assignData)
  },


  /**
   * 获取消缺统计
   * @param {Object} params - 查询参数
   */
  getRemedyStatistics: (params) => {
    return apiService.get('/remedy/statistics', params)
  },

  /**
   * 导出消缺数据
   * @param {Object} params - 导出参数
   */
  exportRemedies: (params) => {
    return apiService.get('/remedy/export', params)
  }
}

/**
 * 统计报表 API
 */
export const statisticsAPI = {
  /**
   * 获取综合统计数据
   * @param {Object} params - 查询参数
   */
  getDashboardStats: (params) => {
    return apiService.get('/statistics/dashboard', params)
  },

  /**
   * 获取任务统计数据
   * @param {Object} params - 查询参数
   */
  getTaskStats: (params) => {
    return apiService.get('/statistics/tasks', params)
  },

  /**
   * 获取缺陷统计数据
   * @param {Object} params - 查询参数
   */
  getDefectStats: (params) => {
    return apiService.get('/statistics/defects', params)
  },

  /**
   * 获取人员统计数据
   * @param {Object} params - 查询参数
   */
  getPersonnelStats: (params) => {
    return apiService.get('/statistics/personnel', params)
  },

  /**
   * 获取用户列表
   * 用于选择负责人等场景
   */
  getUsers: () => {
    return apiService.get('/statistics/users')
  },

  /**
   * 获取地图热力图数据
   * @param {Object} params - 查询参数
   */
  getHeatmapData: (params) => {
    return apiService.get('/statistics/heatmap', params)
  },

  /**
   * 获取自定义统计数据
   * @param {Object} params - 查询参数
   */
  getCustomStats: (params) => {
    return apiService.get('/statistics/custom', params)
  },

  /**
   * 导出统计报表
   * @param {Object} params - 导出参数
   */
  exportStatistics: (params) => {
    return apiService.get('/statistics/export', params)
  }
}

/**
 * 多媒体上传 API
 */
export const mediaAPI = {
  /**
   * 上传文件
   * @param {FormData} formData - 文件数据
   * @param {Function} onProgress - 进度回调
   */
  upload: (formData, onProgress) => {
    return apiService.upload('/media/upload', formData, onProgress)
  },

  /**
   * 批量上传文件
   * @param {FormData} formData - 文件数据
   * @param {Function} onProgress - 进度回调
   */
  batchUpload: (formData, onProgress) => {
    return apiService.upload('/media/batch-upload', formData, onProgress)
  },

  /**
   * 删除文件
   * @param {string} fileId - 文件ID
   */
  delete: (fileId) => {
    return apiService.delete(`/media/${fileId}`)
  }
}
